\section{Strutture dati principali}

Le strutture dati utilizzate dal programma sono basate sul progetto
\emph{SemOpt}.
I singoli argomenti (implementati nella classe \emph{Argument}) contengono,
oltre a delle informazioni \textbf{uniche} del nodo stesso (come il \emph{ID}
ed il  \emph{numero}), anche i dati relativi alle interazioni che esso ha con
gli altri argomenti suoi vicini: in particolare ogni argomento possiede due insiemi:
\begin{enumerate}
  \item uno rappresentante gli argomenti attaccati dal nodo stesso (la lista
  \emph{attacks});
  \item uno rappresentante gli argomenti che attaccano il particolare nodo (la
  lista \emph{attackers});
\end{enumerate}

Per quanto concerne gli insiemi di argumenti, essi sono implementati nella
classe \emph{SetArguments}.
In tale classe i singoli nodi dell'insieme sono immagazzinati in un albero di
ricerca binario, implementato tramite
la classe \emph{std::map}\footnote{la
documentazione della struttura map
\`e disponibile al link http://www.cplusplus.com/reference/map/map/}.
All'interno dell'albero, tuttavia, non sono salvati i valori dei vari Argument,
ma solo i relativi puntatori: in questo modo durante tutto l'arco di vita del
programma, esisterà solo un'unica istanza rappresentante un particolare nodo.
Inoltre è possibile aggiungere ed eliminare nodi dagli insiemi molto pi\`u
velocemente in quanto \`e necessario aggiungere o eliminare solo dei puntatori,
e non le intere strutture all'interno della classe Argument.
Strutturando in tal modo argomenti ed insieme di argomenti, tuttavia, risulta
pi\`u difficile considerare solo un sottoinsieme del grafo iniziale: infatti,
essendo le informazioni riguardanti gli attaccanti e gli attacchi memorizzate non
nell'insieme in s\'e ma nei singoli argomenti, \`e possibile avere un
\emph{SetArguments} $A$, rappresentante per esempio un'intersezione tra due
insiemi, in cui ci sono dei puntatori indicanti degli Argument non più contenuti
nell'insieme stesso.\\
L'intero grafo, comprensivo di ogni argomento e di ogni attacco, \`e strutturato
nella classe \emph{AF} (Argument Framework): in tale classe \`e ovviamente
contenuto un puntatore ad un \emph{SetArguments} (rappresentante l'intero
grafo).
Oltre a ci\`o, la classe prevede altre funzioni, la pi\`u imporante delle quali \`e
\emph{readfile}, consentente di leggere un file rappresentante un grafo.\\
Per quanto concerne una \emph{preferred extension}, essa \`e visibile come un
insieme di \emph{SetArguments}. Le uniche operazioni che devono essere eseguite su tale
struttura dati sono:
\begin{itemize}
  \item unione di due insiemi di \emph{SetArguments};
  \item aggiunta di particolari \emph{Argument} in tutti i \emph{SetArguments}
  all'interno dell'insieme.
\end{itemize}

Dato che le operazioni basilari non accedono alla struttura dati come in un
dizionario ma piuttosto come in una lista si \`e pensato di
implementare questo insieme di \emph{SetArguments} utilizzando la classe
\emph{std::vector}: in questo modo l'esecuzione di alcune istruzioni su ciascun elemento dell'insieme di
\emph{SetArguments} \`e risultata pi\`u facile da realizzare. A livello
implementativo, la classe che rappresenta un insieme di \emph{SetArguments} \`e
denominata \emph{SetArgumentsVector}.

\section{Strutture dati secondarie}

Il programma necessita di un'altra struttura dati: infatti, come richiesto
dall'algoritmo di Tarjan, \`e necessario decorare ogni nodo con 2 attributi interi.
Per implementare ci\`o \`e stata definita la classe ExtendedArgument che rappresenta la decorazione stessa, ossia i 2 interi.\\
Dato che in tale algoritmo ad ogni nodo vengono assegnati questi 2 numeri \`e necessario utilizzare una struttura dati che associ
ad ogni argomento la relativa decorazione ExtendedArgument: tale associazione \`e resa possibile tramite una hashtable che associa ad ogni argomento
(tramite il numero univoco posseduto da ciascun nodo) la relativa decorazione. \`E stata scelta una hashtable in quanto il tipo di accesso
utilizzato per ottenere le decorazioni non \`e sequenziale, bens\`i simile ad un dizionario; inoltre, il tempo di accesso costante della hashtable consente
di velocizzare l'ottenimento dei valori interi richiesti dall'algoritmo. Per l'implementazione della hashtable \`e stata utilizzata la struttura unordered\_map
messa a disposizione da std
\footnote{La documentazione relativa a unordered\_map \`e disponibile al link http://www.cplusplus.com/reference/unordered\_map/unordered\_map/}
.

\section{classi utilizzate}

Il progetto definisce varie classi utilizzate per calcolare la soluzione. Mentre alcune di esse rappresentano concetti chiave utilizzati lungo tutto il programma,
altre servono semplicemente come \emph{wrapper}: esse infatti servono solo per
isolare del particolare codice in modo da aumentare la leggibilit\`a del
progetto stesso.
Altre classi, infine, sono delle classi di facciata (classi \emph{facet}): il loro scopo \`e fornire una pi\`u semplice
 interfaccia per sfruttare le funzioni offerte
dal programma, senza dover scrivere complessi prototipi o utilizzare lunghi pezzi di codice.
Le classi definite all'interno del progetto sono le seguenti:
\\
\begin{tabular}{|c|c|}
	\hline
	AF	& classe del progetto SemOpt \\
	\hline
	Argument	&	classe del progetto SemOpt \\
	\hline
	Boundcond	&	wrapper per l'algoritmo boundcond \\
	\hline
	ExtendedArgument	&	decorazione richiesta dall'algoritmo Tarjan \\
	\hline
	Grounded	&	wrapper per l'algoritmo ground \\
	\hline
	Labelling	&	classe del progetto SemOpt \\
	\hline
	OrClause	&	classe del progetto SemOpt \\
	\hline
	PrefAlgorithm	&	classe facet per fornire una facile interfaccia dell'algoritmo \\
	\hline
	Preferred	&	classe del progetto SemOpt \\
	\hline
	SATFormulae	&	classe del progetto SemOpt \\
	\hline
	SCCSEQ		&	classe wrapper per l'algoritmo SCCSEQ \\
	\hline
	SetArguments	&	classe del progetto SemOpt \\
	\hline
	SetArgumentsVector	&	un vettore di insiemi di argomenti \\
	\hline
\end{tabular}

\section {estensioni delle classi originali in SemOpt}

Alcune classi ereditate dal progetto SemOpt sono state modificate per fornire
delle funzioni più avanzate rispetto a quelle base. Tali modifiche sono tuttavia
solo delle aggiunte: per preservare ogni retrocompatibilità, non sono state
modificate funzioni preesistenti né tanto meno sono stati eliminati metodi.\\

Una delle aggiunte più comuni che sono state eseguite è stata l'overloading
dell'operatore ``>>'' nelle classi in cui non fosse già presente: questa
aggiunta ha permesso di semplificare il rilevamento dei vari bug incontrati
durante lo sviluppo del programma.\\

Overloading dell'operatore ``>>'' a parte, una delle classi in cui sono stati
aggiunti il maggior numero di funzioni è stata la classe \emph{SetArguments}: in
essa sono stati aggiunti i metodi sotto elencati:

\begin{itemize}
  \item \emph{SetArguments(AF af, string names[], int length)};
  \item \emph{vector<SetArguments*> getSingletons()};
  \item \emph{SetArguments* getArgumentAttackersInSet(Argument*)};
  \item \emph{SetArguments* getArgumentAttacksInSet(Argument*)};
  \item \emph{SetArguments* getAllAttackers()};
  \item \emph{SetArguments* getAllAttacks()};
  \item \emph{SetArguments* getAllAttackersInSet()};
  \item \emph{SetArguments* getAllAttacksInSet()};
  \item \emph{SetArguments* getSubsetAttackedBy(SetArguments*)};
  \item \emph{SetArguments* getSubsetAttacks(SetArguments*)};
  \item \emph{SetArguments* getExternalAttackers(void)};
  \item \emph{SetArguments* getExternalAttacks(void)};
  \item \emph{void setRestrictDeprecated(SetArguments*, SetArguments*)};
  \item \emph{void setSafeRestrict(SetArguments*, SetArguments*)};
  \item \emph{void merge(SetArguments*, SetArguments *)};
  \item \emph{void remove\_All\_Arguments()};
  \item \emph{void clean()};
  \item \emph{bool equal(const SetArguments\& other) const};
  \item \emph{bool operator!=(const SetArguments\& other) const};
  \item \emph{void printNodeRelations(void)};
  \item \emph{void printGraph(void)};
  \item \emph{bool graphHasEdges(void)}.
\end{itemize} 

Per i dettagli sul funzionamento delle funzioni (parametri, precondizioni e/o
postcondizioni) è possibile visionare la documentazione del codice, allegata al
progetto.\\

Un'ultima aggiunta che è stata fatta alle classi originarie del progetto SemOpt
è l'introduzione di alcuni iteratori: essi, tuttavia, non offrono sensibili
miglioramenti per quanto concerne le performance dell'algoritmo, ma servono
soltanto per aumentare la leggibilità del codice, come per esempio durante dei
cicli.


\section{funzioni disponibili della classe SetArgumentsVector}

Durante la codifica del progetto è stata realizzata anche una classe
rappresentante un insieme di \emph{SetArguments} (quindi un insieme di insiemi
di \emph{Argument}). Benché la classe contenga poche funzioni, essa è stata
indispensabile per realizzare un codice flessibile e ben leggibile.\\
Il concetto di insiemi di insiemi di \emph{Argument} è utile nell'algoritmo
computante le Preferred Extensions: in esso si richiede di utilizzare l'operatore
$\otimes$, operatore che elabora appunto un insieme di insiemi di
\emph{Argument}.
Per realizzare tale struttura dati, si è utilizzata la struttura \emph{vector}
disponibile nella libreria \emph{std}: abbiamo scelto tale struttura in quanto
l'accesso ai dati in essa contenuti è di tipo sequenziale; dato che anche
all'interno dell'algoritmo un insieme di insiemi di Arguments viene scandagliato elemento
per elemento l'uso la classe \emph{vector} è sembrato appropriato.\\

All'interno della classe \emph{SetArgumentsVector} sono individuabili alcuni
metodi, di seguito riportate:

\begin{itemize}
  \item \emph{static void swap(SetArgumentsVector\& first, SetArgumentsVector\&
  second)};
  \item \emph{SetArgumentsVector()};
  \item \emph{SetArgumentsVector(vector<SetArguments*>\& \_list)};
  \item \emph{virtual \~SetArgumentsVector()};
  \item \emph{void clone(SetArgumentsVector* list)};
  \item \emph{SetArguments* at(unsigned int i) const};
  \item \emph{void push\_back(SetArguments* lab)};
  \item \emph{void clearAll()};
  \item \emph{unsigned int size() const};
  \item \emph{SetArgumentsVectorIterator begin() const};
  \item \emph{SetArgumentsVectorIterator end() const};
  \item \emph{SetArgumentsVector\& operator=(SetArgumentsVector rhs)};
  \item \emph{bool operator==(const SetArgumentsVector \&other) const};
  \item \emph{bool operator!=(const SetArgumentsVector \&other) const};
  \item \emph{bool exist(const SetArguments* lab) const};
  \item \emph{void addSetArgumentsToAll(const SetArguments* set)};
  \item \emph{bool empty()};
  \item \emph{void pop\_back()};
  \item \emph{void printLabellingList()}; 
\end{itemize}

Per i dettagli sul funzionamento delle funzioni (parametri, precondizioni e/o
postcondizioni) è possibile visionare la documentazione del codice, allegata al
progetto.\\

Oltre ai già accennati metodi, la classe \emph{SetArgumentsVector} dispone anche
di un overloading sull'operatore ``+'': tale overloading serve per unire 2
SetArgumentsVector; si è preferito  effettuare un overloading di
un'operatore invece di creare un metodo separato per aumentare la leggibilità
del codice.
